package com.liusy.taskengine;
import java.util.List;
import java.util.Vector;

import org.apache.log4j.Logger;

import com.liusy.taskengine.jobmodel.IJobModel;
import com.liusy.taskengine.listeners.IReleaseTaskListener;
import com.liusy.taskengine.resultmodel.AbstractResultModel;
import com.liusy.taskengine.taskmodel.ITaskModel;


/**
 * 发布任务器（从任务池中找任务，发布任务）
 * 
 * 一个任务发布器的生命周期只能为持到等待排除中的任务池全部完成。（完成之后，所有的多纯程执行器将自动销毁）
 * 如果 等待排除中的任务池全部完成 之后还有新的任务池，则将需要重新new 一个发布器
 * 
 * @author liusy 2012-12-13
 */
public class JobTask extends Thread {
	
	private static Logger log = Logger.getLogger(JobTask.class);
	
	//管理者(管理执行器)
	private TaskManager taskManager = null;
	
	//任务发布器
	private ReleaseTask rt = null;
	
	//任务池接口（任务源）模型
	private IJobModel jobModel = null;
	
	private List<IJobModel> jobModelList = new Vector<IJobModel>();
	
	//是否暂停
	private boolean suspend = false;
	
	
	public JobTask(Vector<IJobModel> v,AbstractResultModel rm){
		this.jobModelList = v;
		initialJobTask(rm);
	}
	
	
	public JobTask(IJobModel jobModel,AbstractResultModel rm){
		this.jobModel = jobModel;
		initialJobTask(rm);
	}
	
	private void initialJobTask(AbstractResultModel rm){
		//初始化任务引擎
		InitialTaskEngine.initTaskEngine();
		//执行器管理
		this.taskManager= new TaskManager(TaskEngineConstant.ON, rm); 
		//发布任务
		this.rt = new ReleaseTask(taskManager);
		rt.start();
		
		log.info(" -----------------------------开始--------------------------");
	}
	
	
	/**
	 * 添加一个等待排队中的任务池
	 * 
	 * @return
	 */
	public void addJobModel(IJobModel jobModel){
		jobModelList.add(jobModel);
	}
	
	/**
	 * 添加一个等待排队中的任务池
	 * 
	 * @return
	 */
	public void addJobModelAll(Vector<IJobModel> list){
		jobModelList.addAll(list);
	}
	
	
	/**
	 * 得到正在等待排队中的任务池的个数
	 * 
	 * @return
	 */
	public int getJobModelCount(){
		return jobModelList.size();
	}
	
	/**
	 * 添加监听任务执行状态
	 * 
	 * @param listenerType
	 * @param lisener
	 */
	public void AddReleaseTaskListener(String listenerType,IReleaseTaskListener lisener)
	{
		this.rt.addListener(listenerType, lisener);
	}
	
	
	/**
	 * 发布任务 
	 * 
	 */
	public void AddReleaseTask(ITaskModel taskModel){
		
			rt.ExeReleaseTask(taskModel);
		
	}
	
	
	@Override
	public void run() {
		try {
			synchronized (this) {
				//同一时间有多个任务池。需等上一个任务池完成后再执行
				while(jobModelList.size()!=0 || null!=jobModel)
				{
					//上一个线程池执行完成后，取出等待中的任务池
					if(null == jobModel)
					{
						jobModel = jobModelList.get(0);
						jobModelList.remove(0);
					}
					if (!suspend) {
						//当缓存中的任务少低于CACHE_TASK_LIMIT时，任务发布器将从任务池中再次获取任务，再进行发布，默认500
						if(rt.getCacheTaskCount() < TaskEngineConstant.CACHE_TASK_LIMIT)
						jobModel.AddReleaseTask(this);
						//开始执行缓存中的任务
						rt.StartCacheTaskStartExecute();
					}else
					{
						log.debug("我是。。。。。。。。。。。。。。。。。。。。。。。。。。wait");
						//暂停
						rt.SuspendCacheTaskStartExecute();
						wait();
					}
					this.sleep(TaskEngineConstant.MONITOR_CACHE_TASK_LIMIT_RATE);
				}
			}
			
		} catch (InterruptedException e) {
			log.error(e.getMessage()+"JobTask  发布任务器（从任务池中找任务，发布任务），不能 被打断 ！！");
		} catch (Exception e) {
			log.error(e.getMessage());
			e.printStackTrace();
		}
	}
	
	/**
	 * 暂停发布从任务池中发布 任务
	 * 
	 * @param suspend
	 */
	public void Suspend() {
		log.debug("暂停发布从任务池中发布 任务。。。。。。。。。。。我被暂停了。。。。。。。。。。。。。。。看时间，如果休息了10000毫秒就对了。");
		this.suspend = true;
	}
	
	/**
	 * 暂停后重新从发布从任务池中发布 任务
	 * 
	 * @param suspend
	 */
	public void reRun() {
		synchronized (this) {
			this.notifyAll();
			log.debug("又开始运行了。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。");
			this.suspend = false;
		}
	}
	/**
	 * 当前发布从任务池中发布 任务，是否已经被暂停
	 * 
	 * @return
	 */
	public boolean isSuspend() {
		return this.suspend;
	}
	
	
	
	/**
	 * 任务池中的任务已经完成
	 * 
	 * @param b
	 */
	public void setJobTaskFinish(boolean b)
	{
		if(b)
		{
			jobModel = null;
		}
	}
}
